#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include <iostream>
#include <vector>
#include <cassert>
#include <cstring>
#include <typeinfo>
#include <mutex>
#include <thread>
#include <memory>
#include <functional>
#include <unordered_map>
#include <condition_variable>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include "Log.hpp"

using namespace LogModule;

#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
public:
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    char *Begin() { return &*_buffer.begin(); } // 对迭代器解引用再取地址（拿到元素的真正地址）
    // 获取当前写入起始地址 _buffer 的空间起始地址，加上偏移量
    char *WritePosition() { return Begin() + _writer_idx; }
    // 获取当前读取起始地址
    char *ReadPosition() { return Begin() + _reader_idx; }
    // 获取缓冲区末尾空闲空间大小--写偏移之后的空闲空间 总体空间大小 - 写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取缓冲区头部空闲空间大小--读偏移之前的空闲空间
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据大小 -- 写偏移 - 读偏移
    uint64_t ReadAbleSize() { return _writer_idx - _reader_idx; }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        assert(len <= ReadAbleSize());
        _reader_idx += len;
    }
    // 将写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        // 向后移动大小必须小于当前后边的空闲空间大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空间足够（整体空间空间够了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        // 如果末尾空闲空间大小足够，直接返回
        if (TailIdleSize() >= len)
            return;
        // 末尾空闲空间大小不够，则判断加上起始位置的空闲空间大小是否足够，够了就将数据移动到起始位置
        if (len <= TailIdleSize() + HeadIdleSize())
        {
            // 将数据移动到起始位置
            uint64_t rsz = ReadAbleSize();                            // 把当前数据大小先保存起来
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
            _reader_idx = 0;                                          // 将读偏移归0
            _writer_idx = rsz;                                        // 将写位置置为可读数据大小，因为当前的可读数据大小就是写偏移量
        }
        else
        {
            // 总体空间不够，则需要扩容，不移动数据，直接给写偏移之后扩容足够空间即可
            _buffer.resize(_writer_idx + len);
        }
    }

    // 写入数据
    void Write(const void *data, uint64_t len)
    {
        if (len == 0)
            return;
        // 1. 保证有足够空间
        EnsureWriteSpace(len);
        // 2. 拷贝数据进去
        const char *d = (const char *)data; // 步长问题 这里把 void* 改为了 char*
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteString(const std::string &data)
    {
        Write((void *)data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBuffer(Buffer &data)
    {
        return Write((void *)data.ReadPosition(), data.ReadAbleSize());
    }
    void WriteBufferAndPush(Buffer &data)
    {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 读取数据
    void Read(void *buf, uint64_t len)
    {
        // 要求获取的数据大小必须小于可读的数据大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsString(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len); // 第0个元素的地址 c_str() 是const的不能改
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }

    // 找回车 '\n'
    char *FindCRLF()
    {
        char *res = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }
    // 通常获取一行数据
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == nullptr)
        {
            return "";
        }
        // +1 把换行符也取出来
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 清空缓冲区
    void Clear()
    {
        _reader_idx = _writer_idx = 0;
    }

private:
    std::vector<char> _buffer; // 使用 vector 进行内存空间管理
    uint64_t _reader_idx;      // 读偏移
    uint64_t _writer_idx;      // 写偏移
};

#define MAX_LISTEN 1024
class Socket
{
public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }
    // 创建套接字
    bool Create()
    {
        // int socket(int domain, int type, int protocol);
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            LOG(LogLevel::ERROR) << "CREATE SOCKET FAILED!";
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(addr);
        // int bind(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "BIND ADDRESS FAILED!";
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        // int listen(int backlog);
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "SOCKET LISTEN FAILED!";
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(addr);
        // int connect(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "CONNECT SERVER FAILED!";
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept()
    {
        // int accept(sockfd, struct sockaddr* addr, socklen_t *len);
        int newfd = accept(_sockfd, nullptr, nullptr);
        if (newfd < 0)
        {
            LOG(LogLevel::ERROR) << "SOCKET ACCEPT FAILED!";
            return -1;
        }
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        // ssize_t recv(int sockfd, void *buf, size_t len, int flag);
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // EAGAIN 当前的 socket 的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR 表示当前socket 的阻塞等待，被信号打断了
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这次没有接收到数据
            }
            LOG(LogLevel::ERROR) << "SOCKET RECV FAILED!";
            return -1;
        }
        return ret; // 实际接受的数据长度
    }
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0)
    {
        // ssize_t send(int sockfd, void *data, size_t len, int flag);
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            LOG(LogLevel::ERROR) << "SOCKET SEND FAILED!";
            return -1;
        }
        return ret; // 实际发送的数据长度
    }
    ssize_t NonBlockSend(void *buf, size_t len)
    {
        if (len == 0)
            return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前发送为非阻塞
    }
    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
    {
        // 1. 创建套接字
        if (Create() == false)
            return false;
        // 2. 设置非阻塞
        if (block_flag)
            NonBlock();
        // 3.启动地址重用   必须放到 bind 之前 因为 bind 函数会检查这个选项来决定是否允许重用地址
        ReuseAddress();
        // 4. 绑定地址
        if (Bind(ip, port) == false)
            return false;
        // 5. 开始监听
        if (Listen() == false)
            return false;
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1. 创建套接字
        if (Create() == false)
            return false;
        // 2. 连接服务器
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字选项 — 开启地址端口重用
    void ReuseAddress()
    {
        // int setsockopt(int fd, int level, int optname, void *val, int vallen);
        // 保证服务器，异常断开之后，可以立即重启，不会有bind问题
        int opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
        opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    }
    // 设置套接字阻塞属性 - 设置为非阻塞
    void NonBlock()
    {
        int f1 = fcntl(_sockfd, F_GETFL);
        if (f1 < 0)
        {
            LOG(LogLevel::ERROR) << "SOCKET FCNTL FAILED!";
            return;
        }
        fcntl(_sockfd, F_SETFL, f1 | O_NONBLOCK); //  O_NONBLOCK 让fd 以非阻塞的方式进行工作
    }

private:
    int _sockfd;
};

class Poller;
class EventLoop;
class Channel
{
public:
    using EventCallback = std::function<void()>;
    Channel(EventLoop *loop, int fd) : _fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; }
    uint32_t Events() { return _events; }                   // 获取想要监控的事件
    void SetREvents(uint32_t events) { _revents = events; } // 设置实际就绪的事件
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 当前是否监控了可读
    bool ReadAble() { return (_events & EPOLLIN); }
    // 当前是否监控了可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update(); // 后边会添加到 EventLoop 的事件监控中
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update(); // 后边会添加到 EventLoop 的事件监控中
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update(); // 后边会修改到 EventLoop 的事件监控中
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update(); // 后边会修改到 EventLoop 的事件监控中
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 移除监控 (从epoll的红黑树上移除掉)
    void Remove();
    void Update();
    // 事件处理，一旦连接触发了事件，就调用这个函数（通过_revents判断调用哪个回调函数）
    void HandleEvent()
    {
        // 对端写端关闭了连接也转换为读事件 对端的半关闭状态
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            // 不管任何事件，都调用的回调函数
            if (_read_callback)
                _read_callback();
        }
        // 有可能会释放连接的操作事件，一次只处理一个
        if (_revents & EPOLLOUT)
        {
            // 不管任何事件，都调用的回调函数
            if (_event_callback)
                _event_callback(); // 放到事件处理完毕后调用，刷新活跃度
            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR)
        {
            if (_event_callback)
                _event_callback();
            if (_error_callback)
                _error_callback(); // 一旦出错，就会释放连接，没必要调用任意回调了 因此要放到前边
        }
        else if (_revents & EPOLLHUP)
        {
            if (_event_callback)
                _event_callback();
            if (_close_callback)
                _close_callback();
        }
        if (_event_callback)
            _event_callback();
    }

private:
    int _fd;
    EventLoop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件

    EventCallback _read_callback;  // 可读事件触发的回调函数
    EventCallback _write_callback; // 可写事件触发的回调函数
    EventCallback _error_callback; // 错误事件触发的回调函数
    EventCallback _close_callback; // 连接断开事件触发的回调函数
    EventCallback _event_callback; // 任意事件触发的回调函数
};

#define MAX_EPOLLEVENTS 1024
class Poller
{
public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            LOG(LogLevel::ERROR) << "EPOLL CREATE FAILED!";
            abort(); // 退出程序
        }
    }
    // 添加或修改监控事件
    void UpdateEvent(Channel *channel)
    {
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 不存在则添加
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除监控
    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃连接
    void Poll(std::vector<Channel *> *active)
    {
        // int epoll_wait(int epfd, struct epoll_event *evs, int maxevents, int timeout);
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if (nfds < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LOG(LogLevel::ERROR) << "EPOLL WAIT  ERROR: " << strerror(errno);
            abort(); // 退出程序
        }
        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置实际就绪的事件
            active->push_back(it->second);
        }
        return;
    }

private:
    // 对 epoll 的直接操作
    void Update(Channel *channel, int op)
    {
        // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
        int fd = channel->Fd();
        struct epoll_event ev;
        memset(&ev, 0, sizeof(ev));
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "EPOLLCTL ERROR!";
        }
        return;
    }
    // 判断一个 Channel 是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
            return false;
        return true;
    }

private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;
};

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;

// 定时器任务类
class TimerTask
{
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb) : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}

    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }

    // 析构的时候执行任务
    ~TimerTask()
    {
        if (_canceled == false)
            _task_cb();
        _release();
    }

private:
    uint64_t _id;         // 定时器任务对象ID
    uint32_t _timeout;    // 定时任务的超时时间
    bool _canceled;       // 任务是否被取消
    TaskFunc _task_cb;    // 定时器对象要执行的定时任务
    ReleaseFunc _release; // 用于删除 TimerWheel 中保存的定时器对象信息 (也是在析构的时候被调用)
};

#define MAX_DELAY 60

// 时间轮
class TimerWheel
{
public:
    TimerWheel(EventLoop *loop) : _capacity(MAX_DELAY), _tick(0), _wheel(_capacity), _loop(loop),
                                  _timerfd(CreateTimerFd()), _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead(); // 启动读事件的监控 (每秒一次)
    }
    // 定时器中有个_timers成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题
    // 如果不想加锁，那就把对定时器的所有操作，都放到一个线程中进行
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    // 刷新 (延迟) 定时器任务
    void TimerRefresh(uint64_t id);
    // 取消任务
    void TimerCancel(uint64_t id);

    // 这个接口存在线程安全问题 -- 这个接口实际上不能被外界使用者调用，只能在模块内，在对应的eventloop线程内执行
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }

private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }
    static int CreateTimerFd()
    {
        // int timerfd_create(int clockid, int flags);  相对时间  默认阻塞
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            LOG(LogLevel::ERROR) << "TIMERFD CREATE ERROR!";
            abort();
        }

        // int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;    // 第一次的超时时间为1秒后
        itime.it_value.tv_nsec = 0;   // 纳秒设置为0
        itime.it_interval.tv_sec = 1; // 第一次超时后，每次超时的时间间隔
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, nullptr);
        return timerfd;
    }
    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "TIMERFD READ FAILED!";
            abort();
        }
        return times;
    }

    // 这个函数应该每秒钟执行一次，相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有定时器对象释放掉 计数--
    }

    void OnTime()
    {
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
        {
            RunTimerTask();
        }
    }

    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt = std::make_shared<TimerTask>(id, delay, cb);
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id)); // 任务被销毁的时候需要从 wheel 中删除
        _timers[id] = WeakTask(pt);
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }

    void TimerRefreshInLoop(uint64_t id)
    {
        // 通过保存的定时器对象的 weak_ptr 然后实例化一个 shared_ptr 出来，添加到 wheel中 这样就是增加同一个引用计数了
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock(); // lock 获取 weak_ptr 管理对象对应的 shared_ptr
        int delay = pt->DelayTime();    // 获取到定时任务初始的延迟时间
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }

    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock();
        if (pt)
            pt->Cancel();
    }

private:
    using WeakTask = std::weak_ptr<TimerTask>; // 二次添加同一个任务对象 要找到同一个计数器
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;                                      // 当前的秒针，走到哪里就释放哪里的对象 (执行哪里的任务)
    int _capacity;                                  // 表盘最大数量 -- 最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;       // 时间轮: 存放智能指针类型 引用计数为 0 执行任务
    std::unordered_map<uint64_t, WeakTask> _timers; // 所有定时器的 weak_ptr 对象 构造出新的 share_ptr 共享计数

    EventLoop *_loop; // 进行 _timerfd 的事件监控
    int _timerfd;     // 定时器描述符 -- 可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;
};

class EventLoop
{
public:
    using Functor = std::function<void()>;
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreateEventFd()),
                  _event_channel(new Channel(this, _event_fd)),
                  _timer_wheel(this)
    {
        // 给 Eventfd 添加可读事件回调函数，读取 eventfd 事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this)); // this ??
        // 启动 eventfd 的读事件监控
        _event_channel->EnableRead();
    }
    void Start()
    {
        while (1)
        {
            // 1. 事件监控
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            // 2. 就绪事件处理
            for (auto &channel : actives)
            {
                channel->HandleEvent();
            }
            // 3. 执行任务
            RunAllTask();
        }
    }
    // 用于判断当前线程是否是 EventLoop 对应的线程
    bool IsInLoop()
    {
        return _thread_id == std::this_thread::get_id();
    }
    void AssertInLoop()
    {
        assert(_thread_id == std::this_thread::get_id());
    }
    // 判断当前执行的操作是否在当前线程，在就直接执行，不在的话就压入任务池{}
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
        {
            return cb();
        }
        return QueueInLoop(cb);
    }
    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞
        // 其实就是给eventfd写入数据，eventfd就会触发可读事件
        WeakUpEventfd();
    }
    // 添加或修改描述符的监控事件
    void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }
    // 移除描述符的监控
    void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timer_wheel.TimerAdd(id, delay, cb); }
    void TimerRefresh(uint64_t id) { return _timer_wheel.TimerRefresh(id); }
    void TimerCancel(uint64_t id) { return _timer_wheel.TimerCancel(id); }
    bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }

private:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> tasks;
        {
            // 执行过程不加锁，减少加锁时间
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.swap(tasks);
        }
        for (auto &f : tasks)
        {
            f();
        }
        return;
    }
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            LOG(LogLevel::ERROR) << "EVENTFD CREATE FAILED!";
            abort(); // 让程序异常退出
        }
        return efd;
    }
    void ReadEventfd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            // EINTR  被信号打断  EAGAIN 无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            LOG(LogLevel::ERROR) << "EVENTFD READ FAILED!";
            abort();
        }
        return;
    }
    void WeakUpEventfd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LOG(LogLevel::ERROR) << "EVENTFD WRITE FAILED!";
            abort();
        }
        return;
    }

private:
    std::thread::id _thread_id;              // 线程 id  确保所有操作都是在同一个线程中执行的
    int _event_fd;                           // eventfd 用于唤醒 IO 事件监控导致的阻塞问题
    std::unique_ptr<Channel> _event_channel; // 对 _event_fd 的管理
    Poller _poller;                          // 进行所有描述符的事件监控

    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;           // 保障任务池的线程安全
    TimerWheel _timer_wheel;     // 定时器模块
};

class LoopThread
{
public:
    // 创建线程，设定线程入口函数
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    // 返回当前关联的 EventLoop 对象指针
    EventLoop *GetLoop()
    {
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&]() -> bool
                       { return _loop != nullptr; });
        }
        return _loop;
    }

private:
    // 实例化 EventLoop 对象，唤醒 cond 上阻塞的线程，并且开始运行 EventLoop 模块的功能
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

private:
    // 用于实现 _loop 获取的同步关系，避免线程创建了，但是 _loop 还没有实例化之前去获取 _loop
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // EventLopp指针对象，这个对象要在 thread 中实例化
    std::thread _thread;           // EventLopp对应的线程
};

class LoopThreadPool
{
public:
    LoopThreadPool(EventLoop *baseloop) : _thread_count(0), _next_idx(0), _baseloop(baseloop)
    {
    }

    void SetThreadCount(int count) { _thread_count = count; }
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
    }
    EventLoop *NextLoop()
    {
        if (_thread_count == 0)
            return _baseloop;
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }

private:
    int _thread_count;
    int _next_idx; // RR 轮转控制
    EventLoop *_baseloop;
    std::vector<LoopThread *> _threads;
    std::vector<EventLoop *> _loops;
};

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };

    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info &type() override { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() override { return new placeholder(_val); }

    public:
        T _val;
    };

    holder *_content;

public:
    Any() : _content(nullptr) {}

    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}

    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr) {}

    ~Any() { delete _content; }

    // 与临时对象进行交换获取资源，然后自动析构掉
    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template <class T>
    T *get()
    {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        // 这里需要转换类型
        return &((placeholder<T> *)_content)->_val;
    }

    // 赋值运算符的重载函数
    template <class T>
    Any &operator=(const T &val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放了
        Any(val).swap(*this); // 在这里析构
        return *this;
    }

    Any &operator=(const Any &other)
    {
        Any(other).swap(*this);
        return *this;
    }
};

// DISCONNECTED -- 连接关闭状态                            CONNECTING -- 连接建立成功 -- 待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态    DISCONNECTING -- 待关闭的状态
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatus;

class Connection : public std::enable_shared_from_this<Connection>
{
public:
    using ptr = std::shared_ptr<Connection>;
    using ConnectedCallback = std::function<void(const ptr &)>;         // 连接建立的回调
    using MessageCallback = std::function<void(const ptr &, Buffer *)>; // 业务回调处理函数
    using ClosedCallback = std::function<void(const ptr &)>;            // 关闭阶段的处理回调
    using AnyEventCallback = std::function<void(const ptr &)>;          // 任意事件触发的处理回调

    Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _conn_id(conn_id), _sockfd(sockfd), _enable_inactive_release(false),
                                                                _loop(loop), _status(CONNECTING), _socket(_sockfd),
                                                                _channel(loop, _sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        // 注意 channel 的读事件监控不能在这里设置
    }
    ~Connection() { LOG(LogLevel::DEBUG) << "RELEASE CONNECTION: " << this;  }
    // 获取管理的文件描述符
    int Fd() { return _sockfd; }
    // 获取连接ID
    int Id() { return _conn_id; }
    // 是否处于Connected状态
    bool Connected() { return _status == CONNECTED; }
    // 设置上下文 -- 连接建立完成时
    void SetContext(const Any &context) { _context = context; }
    // 获取上下文 -- 返回指针
    Any *GetContext() { return &_context; }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callabck = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetServerClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    // 连接建立就绪后，进行 channel 回调设置，启动读监控，调用 _connected_callabck
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }
    // 发送数据 将数据放到发送缓冲区，启动写事件监控
    void Send(const char *data, size_t len)
    {
        // 外界传入的data，可能是个临时空间，我们现在只是把发送操作压入了任务池，有可能没有被立即执行
        // 因此有可能执行的时候，data指向的空间已经被释放了
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 提供给组件使用者的关闭接口 -- 并不实际关闭，需要判断是否有数据待处理
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }
    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }
    // 启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议 -- 重置上下文及阶段处理函数 -- 非线程安全的 必须在线程中立即执行 -- 不能压入到任务队列执行
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行 -- 会导致数据使用原协议处理了
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg, const ClosedCallback &closed, const AnyEventCallback &event)
    {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }

private:
    // 五个 channel 的事件回调函数
    // 描述符可读事件触发后调用，读取接收socket数据放到接收缓冲区中，然后调用 _message_callback 进行事件处理
    void HandleRead()
    {
        // 1. 接收 sockte 的数据，放到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0)
        {
            // 出错了，不能直接关闭连接，还要看缓冲区处理完了没有
            return ShutdownInLoop();
        }
        // 写入之后顺便将写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret);
        // 2. 调用 _message_callback 进行业务处理
        if (_in_buffer.ReadAbleSize() > 0)
        {
            // shared_from_this() 来获取一个当前对象的 std::shared_ptr
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }

    // 描述符可写事件触发后调用，将发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        // outbuffer 中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0)
        {
            if (_in_buffer.ReadAbleSize() > 0)
            {
                // shared_from_this() 来获取一个当前对象的 std::shared_ptr
                return _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release(); // 这时候就是实际的关闭操作了
        }
        _out_buffer.MoveReadOffset(ret); // 千万不要忘了，将读偏移向后移动
        if (_out_buffer.ReadAbleSize() == 0)
        {
            _channel.DisableWrite(); // 发送缓冲区已经没有数据了，不需要写事件监控了
            // 如果当前连接是待关闭状态；则有数据，发送完数据释放连接，没有的话直接释放
            if (_status == DISCONNECTING)
            {
                return Release();
            }
        }
    }
    // 描述符触发挂断事件
    void HandleClose()
    {
        // 一旦连接挂断了，套接字就什么都干不了了，因为有数据待处理就处理一下，完成后关闭连接
        if (_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }
    // 描述符触发出错事件
    void HandleError()
    {
        return HandleClose();
    }
    // 描述符触发任意事件
    void HandleEvent()
    {
        // 1. 如果启用了非活跃超时销毁 就刷新活跃度 2. 调用组件使用者设置的任意事件回调
        if (_enable_inactive_release)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_event_callback)
        {
            _event_callback(shared_from_this());
        }
    }

    // 连接获取之后，所处的状态下要进行各种设置 (启动读监控,调用回调函数)
    void EstablishedInLoop()
    {
        // 1. 修改连接状态  2. 启动读事件监控 3. 调用连接建立的回调函数
        assert(_status == CONNECTING);
        _status = CONNECTED;
        // 一旦启动可能就立即触发可读事件，但是各项回调函数还未设置，所以不能放到构造函数中设置
        _channel.EnableRead();
        if (_connected_callabck)
            _connected_callabck(shared_from_this());
    }
    // 实际的释放接口
    void ReleaseInLoop()
    {
        // 1. 修改连接状态
        _status = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭描述符
        _socket.Close();
        // 4. 如果定时器队列中，还有定时器销毁任务，那么就取消（不然野指针错误）
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();
        // 5. 调用连接关闭的回调函数 避免先移除服务器内部管理的连接信息导致connection对象被释放，先调用组件使用者的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息  释放连接
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }
    // 这个接口并不是实际的发送接口 只是把数据放到了发送缓冲区，然后启动写事件监控，最终由handlewrite写事件触发回调函数来发送
    void SendInLoop(Buffer &buf)
    {
        if (_status == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.WriteAble() == false)
            _channel.EnableWrite();
    }
    // 并非实际的连接释放操作，需要判断有没有数据待处理，代发送
    void ShutdownInLoop()
    {
        _status = DISCONNECTING;
        if (_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        // 要么就是写入数据出错的时候（HandleWrite）关闭连接，要么没有数据待发送，直接关闭连接
        if (_out_buffer.ReadAbleSize() > 0)
        {
            if (_channel.WriteAble() == false)
                _channel.EnableWrite();
        }
        if (_out_buffer.ReadAbleSize() == 0)
            return Release();
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec)
    {
        // 1. 将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2. 添加定时销毁任务 存在就刷新延时即可
        if (_loop->HasTimer(_conn_id))
            return _loop->TimerRefresh(_conn_id);
        // 添加销毁定时任务
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    // 取消非活跃连接超时释放规则
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }
    void UpgradeInLoop(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg, const ClosedCallback &closed, const AnyEventCallback &event)
    {
        // 设置上下文
        _context = context;
        _connected_callabck = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

private:
    uint64_t _conn_id; // 连接的唯一id，便于连接的管理和查找
    // uint64_t _timer_id;              // 定时器ID，必须是唯一的，这块为了简化操作使用conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 判断连接是否启动非活跃销毁的判断标志
    EventLoop *_loop;              // 连接所关联的 EventLoop
    ConnStatus _status;            // 当前连接的状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接事件的管理
    Buffer _in_buffer;             // 输入缓冲区 -- 存放socket中读到的数据
    Buffer _out_buffer;            // 输出缓冲区 -- 存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文

    // 这四个回调函数，是让服务器模块来设置的 (服务器模块的处理回调是组件使用者设定的)
    // 组件使用者使用的
    ConnectedCallback _connected_callabck;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

    // 组件内的关闭连接回调 -- 组件内使用的， 因为服务器组件内会把所有的连接管理起来
    ClosedCallback _server_closed_callback;
};

class Accepter
{
public:
    using AcceptCallback = std::function<void(int)>;
    // 不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动
    // 否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏
    Accepter(EventLoop *loop, int port) : _socket(CreateServer(port)), _loop(loop), _channel(loop, _socket.Fd())
    {
        _channel.SetReadCallback(std::bind(&Accepter::HandleRead, this));
    }

    void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
    void Listen() { _channel.EnableRead(); }

private:
    // 监听套接字的读事件处理回调 -- 获取连接，调用 _accept_callback 函数进行连接处理
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
            return;
        if (_accept_callback)
            _accept_callback(newfd);
    }
    int CreateServer(int port)
    {
        bool ret = _socket.CreateServer(port);
        assert(true == ret);
        return _socket.Fd();
    }

private:
    Socket _socket;   // 用于创建监听套接字
    EventLoop *_loop; // 用于对监听套接字进行事件监控
    Channel _channel; // 用于对监听套接字进行事件管理

    AcceptCallback _accept_callback;
};

class TcpServer
{
public:
    using ConnectedCallback = std::function<void(const Connection::ptr &)>;         // 连接建立的回调
    using MessageCallback = std::function<void(const Connection::ptr &, Buffer *)>; // 业务回调处理函数
    using ClosedCallback = std::function<void(const Connection::ptr &)>;            // 关闭阶段的处理回调
    using AnyEventCallback = std::function<void(const Connection::ptr &)>;          // 任意事件触发的处理回调
    using Functor = std::function<void()>;

    TcpServer(int port)
        : _port(port),
          _next_id(0),
          _enable_inactive_release(false),
          _accepter(&_baseloop, port),
          _pool(&_baseloop)
    {
        // 创建线程池中的从属线程     --- 这是一个 bug 不能在这里 Create，因为此时线程数量还没有被设置，线程数量默认是0，无法创建，getnextloop就会越界访问 threadloop
        // _pool.Create();
        _accepter.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        // 启动 监听读事件监控
        _accepter.Listen();
    }
    void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callabck = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start()
    {
        // 创建线程池中的从属线程 -- 此时线程数量才设置好了
        _pool.Create();
        _baseloop.Start();
    }

private:
    void RunAfterInLoop(const Functor &task, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }
    void NewConnection(int fd)
    {
        _next_id++;
        Connection::ptr conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetConnectedCallback(_connected_callabck);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetServerClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release)
            conn->EnableInactiveRelease(_timeout); // 启动非活跃销毁功能
        conn->Established();                       // 就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }

    void RemoveConnectionInLoop(const Connection::ptr &conn)
    {
        int id = conn->Id();
        _conns.erase(id);
    }

    void RemoveConnection(const Connection::ptr &conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

private:
    uint64_t _next_id; // 自动增长的连接id
    int _port;
    int _timeout;                                         // 这是非活跃连接的统计时间 -- 多长时间无通信就是非活跃连接
    bool _enable_inactive_release;                        // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                  // 主线程的 EventLoop 对象，负责监听事件的处理
    Accepter _accepter;                                   // 监听套接字的管理对象
    LoopThreadPool _pool;                                 // 从属 EventLoop 线程池
    std::unordered_map<uint64_t, Connection::ptr> _conns; // 保存管理所有连接对应的 shared_ptr 对象

    ConnectedCallback _connected_callabck;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
};

void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}

void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}

void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

class NetWork
{
public:
    NetWork()
    {
        LOG(LogLevel::DEBUG) << "SIGPIPE INIT";
        signal(SIGPIPE, SIG_IGN);
    }
};

// 在构造函数中调用 signal(SIGPIPE, SIG_IGN)，确保了在尝试向已关闭套接字写数据时不会被终止
static NetWork nw;

#endif